package artid.com.arttogoa.easemob;

import android.app.Activity;
import android.app.ProgressDialog;
import android.content.ClipboardManager;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.provider.MediaStore;
import android.support.v4.widget.SwipeRefreshLayout;
import android.support.v4.widget.SwipeRefreshLayout.OnRefreshListener;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.View.OnTouchListener;
import android.view.ViewGroup;
import android.view.WindowManager;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.ListView;
import android.widget.TextView;
import android.widget.Toast;

import artid.com.arttogoa.ChatActivity;
import artid.com.arttogoa.parser.EaseOffLineMessageBean;
import artid.com.arttogoa.util.AppUtil;
import artid.com.arttogoa.util.ToastUtil;
import artid.com.arttogoa.util.VioceUtils;
import com.google.gson.Gson;
import com.hyphenate.EMMessageListener;
import com.hyphenate.EMValueCallBack;
import com.hyphenate.chat.EMChatRoom;
import com.hyphenate.chat.EMClient;
import com.hyphenate.chat.EMConversation;
import com.hyphenate.chat.EMGroup;
import com.hyphenate.chat.EMImageMessageBody;
import com.hyphenate.chat.EMMessage;
import com.hyphenate.chat.EMMessage.ChatType;
import com.hyphenate.chat.EMTextMessageBody;
import com.hyphenate.easeui.EaseConstant;
import com.hyphenate.easeui.R;
import com.hyphenate.easeui.controller.EaseUI;
import com.hyphenate.easeui.domain.EaseEmojicon;
import com.hyphenate.easeui.domain.EaseUser;
import com.hyphenate.easeui.model.EaseAtMessageHelper;
import com.hyphenate.easeui.ui.EaseBaiduMapActivity;
import com.hyphenate.easeui.ui.EaseBaseFragment;
import com.hyphenate.easeui.ui.EaseChatRoomListener;
import com.hyphenate.easeui.ui.EaseGroupListener;
import com.hyphenate.easeui.utils.EaseCommonUtils;
import com.hyphenate.easeui.utils.EaseUserUtils;
import com.hyphenate.easeui.widget.EaseAlertDialog;
import com.hyphenate.easeui.widget.EaseAlertDialog.AlertDialogUser;
import com.hyphenate.easeui.widget.EaseChatExtendMenu;
import com.hyphenate.easeui.widget.EaseChatInputMenu;
import com.hyphenate.easeui.widget.EaseChatInputMenu.ChatInputMenuListener;
import com.hyphenate.easeui.widget.EaseChatMessageList;
import com.hyphenate.easeui.widget.EaseVoiceRecorderView;
import com.hyphenate.easeui.widget.EaseVoiceRecorderView.EaseVoiceRecorderCallback;
import com.hyphenate.easeui.widget.chatrow.EaseCustomChatRowProvider;
import com.hyphenate.util.EMLog;
import com.hyphenate.util.PathUtil;
import com.nostra13.universalimageloader.core.ImageLoader;
import org.apache.commons.lang3.StringUtils;
import java.io.File;
import java.util.List;

/**
 * you can new an EaseChatFragment to use or you can inherit it to expand.
 * You need call setArguments to pass chatType and userId
 * <br/>
 * <br/>
 * you can see ChatActivity in demo for your reference
 *
 */
public class EaseChatFragment extends EaseBaseFragment implements EMMessageListener {
	protected static final String TAG = "EaseChatFragment";
	protected static final int REQUEST_CODE_MAP = 1;
	protected static final int REQUEST_CODE_CAMERA = 2;
	protected static final int REQUEST_CODE_LOCAL = 3;

	/**
	 * params to fragment
	 */
	protected Bundle fragmentArgs;
	protected int chatType;
	protected String toChatUsername;
	protected EaseChatMessageList messageList;
	protected EaseChatInputMenu inputMenu;
	protected EMConversation conversation;
	protected InputMethodManager inputManager;
	protected ClipboardManager clipboard;

	protected Handler handler = new Handler();
	protected File cameraFile;
	protected EaseVoiceRecorderView voiceRecorderView;
	protected SwipeRefreshLayout swipeRefreshLayout;
	protected ListView listView;

	protected boolean isloading;
	protected boolean haveMoreData = true;
	protected int pagesize = 20;
	protected GroupListener groupListener;
	protected ChatRoomListener chatRoomListener;

	protected EMMessage contextMenuMessage;

	static final int ITEM_TAKE_PICTURE = 1;
	static final int ITEM_PICTURE = 2;
	static final int ITEM_LOCATION = 3;

	protected int[] itemStrings = { R.string.attach_take_pic, R.string.attach_picture, R.string.attach_location };
	protected int[] itemdrawables = { R.drawable.ease_chat_takepic_selector, R.drawable.ease_chat_image_selector,
			R.drawable.ease_chat_location_selector };
	protected int[] itemIds = { ITEM_TAKE_PICTURE, ITEM_PICTURE, ITEM_LOCATION };
	private boolean isMessageListInited;
	protected MyItemClickListener extendMenuItemClickListener;
	private EditText messageEd;
	private TextView sendMessageBtn;
	private ImageView voice;
	private View headView;
	private ImageLoader mImageLoader;
	public  EMMessage mEMMessage;
	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
		mEMMessage= ChatActivity.message;
		return inflater.inflate(R.layout.fragment_easechat, container, false);
	}

	@Override
	public void onActivityCreated(Bundle savedInstanceState) {

		fragmentArgs = getArguments();
		// check if single chat or group chat
		chatType = fragmentArgs.getInt(EaseConstant.EXTRA_CHAT_TYPE, EaseConstant.CHATTYPE_SINGLE);
		// userId you are chat with or group id
		toChatUsername = fragmentArgs.getString(EaseConstant.EXTRA_USER_ID);

		super.onActivityCreated(savedInstanceState);
	}

	/**
	 * init view
	 */
	protected void initView() {
		// hold to record voice
		//noinspection ConstantConditions
		voiceRecorderView = (EaseVoiceRecorderView) getView().findViewById(R.id.voice_recorder);

		// message list layout
		messageList = (EaseChatMessageList) getView().findViewById(R.id.message_list);
		if(chatType != EaseConstant.CHATTYPE_SINGLE)
			messageList.setShowUserNick(true);
		listView = messageList.getListView();

		extendMenuItemClickListener = new MyItemClickListener();
		inputMenu = (EaseChatInputMenu) getView().findViewById(R.id.input_menu);
		registerExtendMenuItem();
		messageEd=(EditText) getView().findViewById(R.id.chatFragment_sendMessageEd);
		sendMessageBtn=(TextView) getView().findViewById(R.id.chatFragment_sendMessageBtn);
		sendMessageBtn.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				// TODO Auto-generated method stub
				if(!"".equals(messageEd.getText().toString())){
					sendTextMessage(messageEd.getText().toString());
					hideKeyboard();
					messageEd.setText("");
				}else{
					ToastUtil.toast(getActivity(), "您好像忘了点什么");
				}
			}
		});
		voice=(ImageView) getActivity().findViewById(R.id.iv_vioce);
		voice.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				// TODO Auto-generated method stub
				VioceUtils vu = new VioceUtils(getActivity(), voice, messageEd);
				vu.init();
			}
		});
		// init input menu
		inputMenu.init(null);
		inputMenu.setChatInputMenuListener(new ChatInputMenuListener() {

			@Override
			public void onSendMessage(String content) {
				sendTextMessage(content);
			}

			@Override
			public boolean onPressToSpeakBtnTouch(View v, MotionEvent event) {
				return voiceRecorderView.onPressToSpeakBtnTouch(v, event, new EaseVoiceRecorderCallback() {

					@Override
					public void onVoiceRecordComplete(String voiceFilePath, int voiceTimeLength) {
						sendVoiceMessage(voiceFilePath, voiceTimeLength);
					}
				});
			}

			@Override
			public void onBigExpressionClicked(EaseEmojicon emojicon) {
				sendBigExpressionMessage(emojicon.getName(), emojicon.getIdentityCode());
			}
		});

		swipeRefreshLayout = messageList.getSwipeRefreshLayout();
		swipeRefreshLayout.setColorSchemeResources(R.color.holo_blue_bright, R.color.holo_green_light,
				R.color.holo_orange_light, R.color.holo_red_light);

		inputManager = (InputMethodManager) getActivity().getSystemService(Context.INPUT_METHOD_SERVICE);
		clipboard = (ClipboardManager) getActivity().getSystemService(Context.CLIPBOARD_SERVICE);
		getActivity().getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_HIDDEN);
		if(mEMMessage!=null){
			//这里主要是第一次进入发送消息
			if(mEMMessage.getBooleanAttribute("isSendMessage",false)){
				sendTextMessage("");
			}
		}
	}

	protected void setUpView() {
		titleBar.setTitle(toChatUsername);
		if (chatType == EaseConstant.CHATTYPE_SINGLE) {
			// set title
			if(EaseUserUtils.getUserInfo(toChatUsername) != null){
				EaseUser user = EaseUserUtils.getUserInfo(toChatUsername);
				if (user != null) {
					titleBar.setTitle(user.getNick());
				}
			}
			titleBar.setRightImageResource(R.drawable.ease_mm_title_remove);
		} else {
			titleBar.setRightImageResource(R.drawable.ease_to_group_details_normal);
			if (chatType == EaseConstant.CHATTYPE_GROUP) {
				//group chat
				EMGroup group = EMClient.getInstance().groupManager().getGroup(toChatUsername);
				if (group != null)
					titleBar.setTitle(group.getGroupName());
				// listen the event that user moved out group or group is dismissed
				groupListener = new GroupListener();
				EMClient.getInstance().groupManager().addGroupChangeListener(groupListener);
			} else {
				chatRoomListener = new ChatRoomListener();
				EMClient.getInstance().chatroomManager().addChatRoomChangeListener(chatRoomListener);
				onChatRoomViewCreation();
			}

		}
		if (chatType != EaseConstant.CHATTYPE_CHATROOM) {
			onConversationInit();
			onMessageListInit();
		}

		titleBar.setLeftLayoutClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				onBackPressed();
			}
		});
		titleBar.setRightLayoutClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				if (chatType == EaseConstant.CHATTYPE_SINGLE) {
					emptyHistory();
				} else {
					toGroupDetails();
				}
			}
		});

		setRefreshLayoutListener();

		// show forward message if the message is not null
		String forward_msg_id = getArguments().getString("forward_msg_id");
		if (forward_msg_id != null) {
			forwardMessage(forward_msg_id);
		}
	}

	/**
	 * register extend menu, item id need > 3 if you override this method and keep exist item
	 */
	protected void registerExtendMenuItem(){
		for(int i = 0; i < itemStrings.length; i++){
			inputMenu.registerExtendMenuItem(itemStrings[i], itemdrawables[i], itemIds[i], extendMenuItemClickListener);
		}
	}


	protected void onConversationInit(){
		conversation = EMClient.getInstance().chatManager().getConversation(toChatUsername, EaseCommonUtils.getConversationType(chatType), true);
		conversation.markAllMessagesAsRead();
		// the number of messages loaded into conversation is getChatOptions().getNumberOfMessagesLoaded
		// you can change this number
		final List<EMMessage> msgs = conversation.getAllMessages();
		int msgCount = msgs != null ? msgs.size() : 0;
		if (msgCount < conversation.getAllMsgCount() && msgCount < pagesize) {
			String msgId = null;
			if (msgs != null && msgs.size() > 0) {
				msgId = msgs.get(0).getMsgId();
			}
			conversation.loadMoreMsgFromDB(msgId, pagesize - msgCount);
		}

	}

	protected void onMessageListInit(){
		messageList.init(toChatUsername, chatType, chatFragmentHelper != null ?
				chatFragmentHelper.onSetCustomChatRowProvider() : null);
		setListItemClickListener();

		messageList.getListView().setOnTouchListener(new OnTouchListener() {

			@Override
			public boolean onTouch(View v, MotionEvent event) {
				hideKeyboard();
				inputMenu.hideExtendMenuContainer();
				return false;
			}
		});

		isMessageListInited = true;
	}

	protected void setListItemClickListener() {
		messageList.setItemClickListener(new EaseChatMessageList.MessageListItemClickListener() {

			@Override
			public void onUserAvatarClick(String username) {
				if(chatFragmentHelper != null){
					chatFragmentHelper.onAvatarClick(username);
				}
			}

			@Override
			public void onUserAvatarLongClick(String username) {
				if(chatFragmentHelper != null){
					chatFragmentHelper.onAvatarLongClick(username);
				}
			}

			@Override
			public void onResendClick(final EMMessage message) {
				new EaseAlertDialog(getActivity(), R.string.resend, R.string.confirm_resend, null, new AlertDialogUser() {
					@Override
					public void onResult(boolean confirmed, Bundle bundle) {
						if (!confirmed) {
							return;
						}
						resendMessage(message);
					}
				}, true).show();
			}

			@Override
			public void onBubbleLongClick(EMMessage message) {
				contextMenuMessage = message;
				if(chatFragmentHelper != null){
					chatFragmentHelper.onMessageBubbleLongClick(message);
				}
			}

			@Override
			public boolean onBubbleClick(EMMessage message) {
				if(chatFragmentHelper == null){
					return false;
				}
				return chatFragmentHelper.onMessageBubbleClick(message);
			}

		});
	}

	protected void setRefreshLayoutListener() {
		swipeRefreshLayout.setOnRefreshListener(new OnRefreshListener() {

			@Override
			public void onRefresh() {
				new Handler().postDelayed(new Runnable() {

					@Override
					public void run() {
						if (listView.getFirstVisiblePosition() == 0 && !isloading && haveMoreData) {
							List<EMMessage> messages;
							try {
								if (chatType == EaseConstant.CHATTYPE_SINGLE) {
									messages = conversation.loadMoreMsgFromDB(messageList.getItem(0).getMsgId(),
											pagesize);
								} else {
									messages = conversation.loadMoreMsgFromDB(messageList.getItem(0).getMsgId(),
											pagesize);
								}
							} catch (Exception e1) {
								swipeRefreshLayout.setRefreshing(false);
								return;
							}
							if (messages.size() > 0) {
								messageList.refreshSeekTo(messages.size() - 1);
								if (messages.size() != pagesize) {
									haveMoreData = false;
								}
							} else {
								haveMoreData = false;
							}

							isloading = false;

						} else {
							Toast.makeText(getActivity(), getResources().getString(R.string.no_more_messages),
									Toast.LENGTH_SHORT).show();
						}
						swipeRefreshLayout.setRefreshing(false);
					}
				}, 600);
			}
		});
	}

	@Override
	public void onActivityResult(int requestCode, int resultCode, Intent data) {
		super.onActivityResult(requestCode, resultCode, data);
		if (resultCode == Activity.RESULT_OK) {
			if (requestCode == REQUEST_CODE_CAMERA) { // capture new image
				if (cameraFile != null && cameraFile.exists())
					sendImageMessage(cameraFile.getAbsolutePath());
			} else if (requestCode == REQUEST_CODE_LOCAL) { // send local image
				if (data != null) {
					Uri selectedImage = data.getData();
					if (selectedImage != null) {
						sendPicByUri(selectedImage);
					}
				}
			} else if (requestCode == REQUEST_CODE_MAP) { // location
				double latitude = data.getDoubleExtra("latitude", 0);
				double longitude = data.getDoubleExtra("longitude", 0);
				String locationAddress = data.getStringExtra("address");
				if (locationAddress != null && !locationAddress.equals("")) {
					sendLocationMessage(latitude, longitude, locationAddress);
				} else {
					Toast.makeText(getActivity(), R.string.unable_to_get_loaction, Toast.LENGTH_SHORT).show();
				}

			}
		}
	}


	@Override
	public void onResume() {
		super.onResume();
		if(isMessageListInited)
			messageList.refresh();
		EaseUI.getInstance().pushActivity(getActivity());
		// register the event listener when enter the foreground
		EMClient.getInstance().chatManager().addMessageListener(this);

		if(chatType == EaseConstant.CHATTYPE_GROUP){
			EaseAtMessageHelper.get().removeAtMeGroup(toChatUsername);
		}
	}

	@Override
	public void onStop() {
		super.onStop();
		// unregister this event listener when this activity enters the
		// background
		EMClient.getInstance().chatManager().removeMessageListener(this);

		// remove activity from foreground activity list
		EaseUI.getInstance().popActivity(getActivity());
	}

	@Override
	public void onDestroy() {
		super.onDestroy();

		if (groupListener != null) {
			EMClient.getInstance().groupManager().removeGroupChangeListener(groupListener);
		}

		if (chatRoomListener != null) {
			EMClient.getInstance().chatroomManager().removeChatRoomListener(chatRoomListener);
		}

		if(chatType == EaseConstant.CHATTYPE_CHATROOM){
			EMClient.getInstance().chatroomManager().leaveChatRoom(toChatUsername);
		}
	}

	public void onBackPressed() {
		if (inputMenu.onBackPressed()) {
			getActivity().finish();
			if(chatType == EaseConstant.CHATTYPE_GROUP){
				EaseAtMessageHelper.get().removeAtMeGroup(toChatUsername);
				EaseAtMessageHelper.get().cleanToAtUserList();
			}
			if (chatType == EaseConstant.CHATTYPE_CHATROOM) {
				EMClient.getInstance().chatroomManager().leaveChatRoom(toChatUsername);
			}
		}
	}

	protected void onChatRoomViewCreation() {
		final ProgressDialog pd = ProgressDialog.show(getActivity(), "", "Joining......");
		EMClient.getInstance().chatroomManager().joinChatRoom(toChatUsername, new EMValueCallBack<EMChatRoom>() {

			@Override
			public void onSuccess(final EMChatRoom value) {
				getActivity().runOnUiThread(new Runnable() {
					@Override
					public void run() {
						if(getActivity().isFinishing() || !toChatUsername.equals(value.getId()))
							return;
						pd.dismiss();
						EMChatRoom room = EMClient.getInstance().chatroomManager().getChatRoom(toChatUsername);
						if (room != null) {
							titleBar.setTitle(room.getName());
							EMLog.d(TAG, "join room success : " + room.getName());
						} else {
							titleBar.setTitle(toChatUsername);
						}
						addChatRoomChangeListenr();
						onConversationInit();
						onMessageListInit();
					}
				});
			}

			@Override
			public void onError(final int error, String errorMsg) {
				// TODO Auto-generated method stub
				EMLog.d(TAG, "join room failure : " + error);
				getActivity().runOnUiThread(new Runnable() {
					@Override
					public void run() {
						pd.dismiss();
					}
				});
				getActivity().finish();
			}
		});
	}

	protected void addChatRoomChangeListenr() {
        /*
        chatRoomChangeListener = new EMChatRoomChangeListener() {

            @Override
            public void onChatRoomDestroyed(String roomId, String roomName) {
                if (roomId.equals(toChatUsername)) {
                    showChatroomToast(" room : " + roomId + " with room name : " + roomName + " was destroyed");
                    getActivity().finish();
                }
            }

            @Override
            public void onMemberJoined(String roomId, String participant) {
                showChatroomToast("member : " + participant + " join the room : " + roomId);
            }

            @Override
            public void onMemberExited(String roomId, String roomName, String participant) {
                showChatroomToast("member : " + participant + " leave the room : " + roomId + " room name : " + roomName);
            }

            @Override
            public void onRemovedFromChatRoom(String roomId, String roomName, String participant) {
                if (roomId.equals(toChatUsername)) {
                    String curUser = EMClient.getInstance().getCurrentUser();
                    if (curUser.equals(participant)) {
                    	EMClient.getInstance().chatroomManager().leaveChatRoom(toChatUsername);
                        getActivity().finish();
                    }else{
                        showChatroomToast("member : " + participant + " was kicked from the room : " + roomId + " room name : " + roomName);
                    }
                }
            }


            // ============================= group_reform new add api begin
            @Override
            public void onMuteListAdded(String chatRoomId, Map<String, Long> mutes) {}

            @Override
            public void onMuteListRemoved(String chatRoomId, List<String> mutes) {}

            @Override
            public void onAdminAdded(String chatRoomId, String admin) {}

            @Override
            public void onAdminRemoved(String chatRoomId, String admin) {}

            @Override
            public void onOwnerChanged(String chatRoomId, String newOwner, String oldOwner) {}

            // ============================= group_reform new add api end

        };

        EMClient.getInstance().chatroomManager().addChatRoomChangeListener(chatRoomChangeListener);
        */
	}

	protected void showChatroomToast(final String toastContent){
		getActivity().runOnUiThread(new Runnable() {
			public void run() {
				Toast.makeText(getActivity(), toastContent, Toast.LENGTH_SHORT).show();
			}
		});
	}

	// implement methods in EMMessageListener
	@Override
	public void onMessageReceived(List<EMMessage> messages) {
		for (EMMessage message : messages) {
			String username = null;
			// group message
			if (message.getChatType() == ChatType.GroupChat || message.getChatType() == ChatType.ChatRoom) {
				username = message.getTo();
			} else {
				// single chat message
				username = message.getFrom();
			}

			// if the message is for current conversation
			if (username.equals(toChatUsername) || message.getTo().equals(toChatUsername)) {
				messageList.refreshSelectLast();
				EaseUI.getInstance().getNotifier().vibrateAndPlayTone(message);
				conversation.markMessageAsRead(message.getMsgId());
			} else {
				EaseUI.getInstance().getNotifier().onNewMsg(message);
			}
		}
	}

	@Override
	public void onCmdMessageReceived(List<EMMessage> messages) {

	}

	@Override
	public void onMessageRead(List<EMMessage> messages) {
		if(isMessageListInited) {
			messageList.refresh();
		}
	}

	@Override
	public void onMessageDelivered(List<EMMessage> messages) {
		if(isMessageListInited) {
			messageList.refresh();
		}
	}

	@Override
	public void onMessageChanged(EMMessage emMessage, Object change) {
		if(isMessageListInited) {
			messageList.refresh();
		}
	}


	/**
	 * handle the click event for extend menu
	 *
	 */
	class MyItemClickListener implements EaseChatExtendMenu.EaseChatExtendMenuItemClickListener{

		@Override
		public void onClick(int itemId, View view) {
			if(chatFragmentHelper != null){
				if(chatFragmentHelper.onExtendMenuItemClick(itemId, view)){
					return;
				}
			}
			switch (itemId) {
				case ITEM_TAKE_PICTURE:
					selectPicFromCamera();
					break;
				case ITEM_PICTURE:
					selectPicFromLocal();
					break;
				case ITEM_LOCATION:
					startActivityForResult(new Intent(getActivity(), EaseBaiduMapActivity.class), REQUEST_CODE_MAP);
					break;

				default:
					break;
			}
		}

	}

	/**
	 * input @
	 * @param username
	 */
	protected void inputAtUsername(String username, boolean autoAddAtSymbol){
		if(EMClient.getInstance().getCurrentUser().equals(username) ||
				chatType != EaseConstant.CHATTYPE_GROUP){
			return;
		}
		EaseAtMessageHelper.get().addAtUser(username);
		EaseUser user = EaseUserUtils.getUserInfo(username);
		if (user != null){
			username = user.getNick();
		}
		if(autoAddAtSymbol)
			inputMenu.insertText("@" + username + " ");
		else
			inputMenu.insertText(username + " ");
	}


	/**
	 * input @
	 * @param username
	 */
	protected void inputAtUsername(String username){
		inputAtUsername(username, true);
	}
/*

    环信自己的文本消息发送
    //send message
    protected void sendTextMessage(String content) {
        if(EaseAtMessageHelper.get().containsAtUsername(content)){
            sendAtMessage(content);
        }else{
            EMMessage message = EMMessage.createTxtSendMessage(content, toChatUsername);
            sendMessage(message);
        }
    }
*/

	/**
	 * send @ message, only support group chat message
	 * @param content
	 */
	@SuppressWarnings("ConstantConditions")
	private void sendAtMessage(String content){
		if(chatType != EaseConstant.CHATTYPE_GROUP){
			EMLog.e(TAG, "only support group chat message");
			return;
		}
		EMMessage message = EMMessage.createTxtSendMessage(content, toChatUsername);
		EMGroup group = EMClient.getInstance().groupManager().getGroup(toChatUsername);
		if(EMClient.getInstance().getCurrentUser().equals(group.getOwner()) && EaseAtMessageHelper.get().containsAtAll(content)){
			message.setAttribute(EaseConstant.MESSAGE_ATTR_AT_MSG, EaseConstant.MESSAGE_ATTR_VALUE_AT_MSG_ALL);
		}else {
			message.setAttribute(EaseConstant.MESSAGE_ATTR_AT_MSG,
					EaseAtMessageHelper.get().atListToJsonArray(EaseAtMessageHelper.get().getAtMessageUsernames(content)));
		}
		sendMessage(message);

	}


	protected void sendBigExpressionMessage(String name, String identityCode){
		EMMessage message = EaseCommonUtils.createExpressionMessage(toChatUsername, name, identityCode);
		sendMessage(message);
	}

	protected void sendVoiceMessage(String filePath, int length) {
		EMMessage message = EMMessage.createVoiceSendMessage(filePath, length, toChatUsername);
		sendMessage(message);
	}

	protected void sendImageMessage(String imagePath) {
		EMMessage message = EMMessage.createImageSendMessage(imagePath, false, toChatUsername);
		sendMessage(message);
	}

	protected void sendLocationMessage(double latitude, double longitude, String locationAddress) {
		EMMessage message = EMMessage.createLocationSendMessage(latitude, longitude, locationAddress, toChatUsername);
		sendMessage(message);
	}

	protected void sendVideoMessage(String videoPath, String thumbPath, int videoLength) {
		EMMessage message = EMMessage.createVideoSendMessage(videoPath, thumbPath, videoLength, toChatUsername);
		sendMessage(message);
	}

	protected void sendFileMessage(String filePath) {
		EMMessage message = EMMessage.createFileSendMessage(filePath, toChatUsername);
		sendMessage(message);
	}


	//发送消息方法
	//==========================================================================
	public void sendTextMessage(String content) {
		System.out.println(content);
		//扩展消息（A_head：A端头像；A_name：端用户名）
		EMMessage message = null;
		if(!StringUtils.isEmpty(mEMMessage.getStringAttribute("artDescribe",""))){
			message = EMMessage.createTxtSendMessage("#"+mEMMessage.getStringAttribute("artDescribe","")+"#"+content, toChatUsername);
		}else{
			message = EMMessage.createTxtSendMessage(content, toChatUsername);
		}
		//C端头像
		message.setAttribute("artistURL", mEMMessage.getStringAttribute("artistURL",""));
		//C端名字
		message.setAttribute("fromName", mEMMessage.getStringAttribute("fromName",""));
		//作品名称
		message.setAttribute("artDescribe",mEMMessage.getStringAttribute("artDescribe",""));
		//A端头像
		message.setAttribute("A_head", AppUtil.getUser().getAvatarurl());
		//A端名字
		message.setAttribute("A_name", AppUtil.getUser().getRealname());
		//C端ID
		message.setAttribute("C_uid", toChatUsername);
		if(mEMMessage.getBooleanAttribute("isSendMessage",false)) {
			//发送图片
			message.setAttribute("artUrl", mEMMessage.getStringAttribute("artUrl", ""));
			//还原状态，防止在当前页面发送信息的时候还在发送图片
			mEMMessage.setAttribute("isSendMessage",false);
		}
		//IOS标识图文混排
		//离线内容
		EaseOffLineMessageBean bean=new EaseOffLineMessageBean();
		bean.setA_head(AppUtil.getUser().getAvatarurl());
		bean.setA_name(AppUtil.getUser().getRealname());
		bean.setArtDescribe(mEMMessage.getStringAttribute("artDescribe",""));
		bean.setArtistURL(mEMMessage.getStringAttribute("artistURL",""));
		bean.setC_uid(toChatUsername);
		bean.setFromName(mEMMessage.getStringAttribute("fromName",""));
		String em_apns_ext=new Gson().toJson(bean);
		//离线消息
		message.setAttribute("em_apns_ext", em_apns_ext);
		sendMessage(message);
	}
	protected void sendMessage(EMMessage message){
		if (message == null) {
			return;
		}
		if(chatFragmentHelper != null){
			//set extension
			chatFragmentHelper.onSetMessageAttributes(message);
		}
		if (chatType == EaseConstant.CHATTYPE_GROUP){
			message.setChatType(ChatType.GroupChat);
		}else if(chatType == EaseConstant.CHATTYPE_CHATROOM){
			message.setChatType(ChatType.ChatRoom);
		}
		//send message
		EMClient.getInstance().chatManager().sendMessage(message);
		//refresh ui
		if(isMessageListInited) {
			messageList.refreshSelectLast();
		}
	}


	public void resendMessage(EMMessage message){
		message.setStatus(EMMessage.Status.CREATE);
		EMClient.getInstance().chatManager().sendMessage(message);
		messageList.refresh();
	}

	//===================================================================================


	/**
	 * send image
	 *
	 * @param selectedImage
	 */
	protected void sendPicByUri(Uri selectedImage) {
		String[] filePathColumn = { MediaStore.Images.Media.DATA };
		Cursor cursor = getActivity().getContentResolver().query(selectedImage, filePathColumn, null, null, null);
		if (cursor != null) {
			cursor.moveToFirst();
			int columnIndex = cursor.getColumnIndex(filePathColumn[0]);
			String picturePath = cursor.getString(columnIndex);
			cursor.close();
			cursor = null;

			if (picturePath == null || picturePath.equals("null")) {
				Toast toast = Toast.makeText(getActivity(), R.string.cant_find_pictures, Toast.LENGTH_SHORT);
				toast.setGravity(Gravity.CENTER, 0, 0);
				toast.show();
				return;
			}
			sendImageMessage(picturePath);
		} else {
			File file = new File(selectedImage.getPath());
			if (!file.exists()) {
				Toast toast = Toast.makeText(getActivity(), R.string.cant_find_pictures, Toast.LENGTH_SHORT);
				toast.setGravity(Gravity.CENTER, 0, 0);
				toast.show();
				return;

			}
			sendImageMessage(file.getAbsolutePath());
		}

	}

	/**
	 * send file
	 * @param uri
	 */
	protected void sendFileByUri(Uri uri){
		String filePath = null;
		if ("content".equalsIgnoreCase(uri.getScheme())) {
			String[] filePathColumn = { MediaStore.Images.Media.DATA };
			Cursor cursor = null;

			try {
				cursor = getActivity().getContentResolver().query(uri, filePathColumn, null, null, null);
				int column_index = cursor.getColumnIndexOrThrow("_data");
				if (cursor.moveToFirst()) {
					filePath = cursor.getString(column_index);
				}
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				if (cursor != null) {
					cursor.close();
				}
			}
		} else if ("file".equalsIgnoreCase(uri.getScheme())) {
			filePath = uri.getPath();
		}
		if (filePath == null) {
			return;
		}
		File file = new File(filePath);
		if (!file.exists()) {
			Toast.makeText(getActivity(), R.string.File_does_not_exist, Toast.LENGTH_SHORT).show();
			return;
		}
		//limit the size < 10M
		if (file.length() > 10 * 1024 * 1024) {
			Toast.makeText(getActivity(), R.string.The_file_is_not_greater_than_10_m, Toast.LENGTH_SHORT).show();
			return;
		}
		sendFileMessage(filePath);
	}

	/**
	 * capture new image
	 */
	protected void selectPicFromCamera() {
		if (!EaseCommonUtils.isSdcardExist()) {
			Toast.makeText(getActivity(), R.string.sd_card_does_not_exist, Toast.LENGTH_SHORT).show();
			return;
		}

		cameraFile = new File(PathUtil.getInstance().getImagePath(), EMClient.getInstance().getCurrentUser()
				+ System.currentTimeMillis() + ".jpg");
		//noinspection ResultOfMethodCallIgnored
		cameraFile.getParentFile().mkdirs();
		startActivityForResult(
				new Intent(MediaStore.ACTION_IMAGE_CAPTURE).putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(cameraFile)),
				REQUEST_CODE_CAMERA);
	}

	/**
	 * select local image
	 */
	protected void selectPicFromLocal() {
		Intent intent;
		if (Build.VERSION.SDK_INT < 19) {
			intent = new Intent(Intent.ACTION_GET_CONTENT);
			intent.setType("image/*");

		} else {
			intent = new Intent(Intent.ACTION_PICK, android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
		}
		startActivityForResult(intent, REQUEST_CODE_LOCAL);
	}



	/**
	 * clear the conversation history
	 *
	 */
	protected void emptyHistory() {
		String msg = getResources().getString(R.string.Whether_to_empty_all_chats);
		new EaseAlertDialog(getActivity(),null, msg, null,new AlertDialogUser() {

			@Override
			public void onResult(boolean confirmed, Bundle bundle) {
				if(confirmed){
					if (conversation != null) {
						conversation.clearAllMessages();
					}
					messageList.refresh();
				}
			}
		}, true).show();
	}

	/**
	 * open group detail
	 *
	 */
	protected void toGroupDetails() {
		if (chatType == EaseConstant.CHATTYPE_GROUP) {
			EMGroup group = EMClient.getInstance().groupManager().getGroup(toChatUsername);
			if (group == null) {
				Toast.makeText(getActivity(), R.string.gorup_not_found, Toast.LENGTH_SHORT).show();
				return;
			}
			if(chatFragmentHelper != null){
				chatFragmentHelper.onEnterToChatDetails();
			}
		}else if(chatType == EaseConstant.CHATTYPE_CHATROOM){
			if(chatFragmentHelper != null){
				chatFragmentHelper.onEnterToChatDetails();
			}
		}
	}

	/**
	 * hide
	 */
	protected void hideKeyboard() {
		if (getActivity().getWindow().getAttributes().softInputMode != WindowManager.LayoutParams.SOFT_INPUT_STATE_HIDDEN) {
			if (getActivity().getCurrentFocus() != null)
				inputManager.hideSoftInputFromWindow(getActivity().getCurrentFocus().getWindowToken(),
						InputMethodManager.HIDE_NOT_ALWAYS);
		}
	}

	/**
	 * forward message
	 *
	 * @param forward_msg_id
	 */
	protected void forwardMessage(String forward_msg_id) {
		final EMMessage forward_msg = EMClient.getInstance().chatManager().getMessage(forward_msg_id);
		EMMessage.Type type = forward_msg.getType();
		switch (type) {
			case TXT:
				if(forward_msg.getBooleanAttribute(EaseConstant.MESSAGE_ATTR_IS_BIG_EXPRESSION, false)){
					sendBigExpressionMessage(((EMTextMessageBody) forward_msg.getBody()).getMessage(),
							forward_msg.getStringAttribute(EaseConstant.MESSAGE_ATTR_EXPRESSION_ID, null));
				}else{
					// get the content and send it
					String content = ((EMTextMessageBody) forward_msg.getBody()).getMessage();
					sendTextMessage(content);
				}
				break;
			case IMAGE:
				// send image
				String filePath = ((EMImageMessageBody) forward_msg.getBody()).getLocalUrl();
				if (filePath != null) {
					File file = new File(filePath);
					if (!file.exists()) {
						// send thumb nail if original image does not exist
						filePath = ((EMImageMessageBody) forward_msg.getBody()).thumbnailLocalPath();
					}
					sendImageMessage(filePath);
				}
				break;
			default:
				break;
		}

		if(forward_msg.getChatType() == EMMessage.ChatType.ChatRoom){
			EMClient.getInstance().chatroomManager().leaveChatRoom(forward_msg.getTo());
		}
	}

	/**
	 * listen the group event
	 *
	 */
	class GroupListener extends EaseGroupListener {

		@Override
		public void onUserRemoved(final String groupId, String groupName) {
			getActivity().runOnUiThread(new Runnable() {

				public void run() {
					if (toChatUsername.equals(groupId)) {
						Toast.makeText(getActivity(), R.string.you_are_group, Toast.LENGTH_LONG).show();
						Activity activity = getActivity();
						if (activity != null && !activity.isFinishing()) {
							activity.finish();
						}
					}
				}
			});
		}

		@Override
		public void onGroupDestroyed(final String groupId, String groupName) {
			// prompt group is dismissed and finish this activity
			getActivity().runOnUiThread(new Runnable() {
				public void run() {
					if (toChatUsername.equals(groupId)) {
						Toast.makeText(getActivity(), R.string.the_current_group_destroyed, Toast.LENGTH_LONG).show();
						Activity activity = getActivity();
						if (activity != null && !activity.isFinishing()) {
							activity.finish();
						}
					}
				}
			});
		}
	}

	/**
	 * listen chat room event
	 */
	class ChatRoomListener extends EaseChatRoomListener {

		@Override
		public void onChatRoomDestroyed(final String roomId, final String roomName) {
			getActivity().runOnUiThread(new Runnable() {
				public void run() {
					if (roomId.equals(toChatUsername)) {
						Toast.makeText(getActivity(), R.string.the_current_chat_room_destroyed, Toast.LENGTH_LONG).show();
						Activity activity = getActivity();
						if (activity != null && !activity.isFinishing()) {
							activity.finish();
						}
					}
				}
			});
		}

		@Override
		public void onRemovedFromChatRoom(final String roomId, final String roomName, final String participant) {
			getActivity().runOnUiThread(new Runnable() {
				public void run() {
					if (roomId.equals(toChatUsername)) {
						Toast.makeText(getActivity(), R.string.quiting_the_chat_room, Toast.LENGTH_LONG).show();
						Activity activity = getActivity();
						if (activity != null && !activity.isFinishing()) {
							activity.finish();
						}
					}
				}
			});
		}

		@Override
		public void onMemberJoined(final String roomId, final String participant) {
			if (roomId.equals(toChatUsername)) {
				getActivity().runOnUiThread(new Runnable() {
					public void run() {
						Toast.makeText(getActivity(), "member join:" + participant, Toast.LENGTH_LONG).show();
					}
				});
			}
		}

		@Override
		public void onMemberExited(final String roomId, final String roomName, final String participant) {
			if (roomId.equals(toChatUsername)) {
				getActivity().runOnUiThread(new Runnable() {
					public void run() {
						Toast.makeText(getActivity(), "member exit:" + participant, Toast.LENGTH_LONG).show();
					}
				});
			}
		}


	}

	protected EaseChatFragmentHelper chatFragmentHelper;
	public void setChatFragmentListener(EaseChatFragmentHelper chatFragmentHelper){
		this.chatFragmentHelper = chatFragmentHelper;
	}

	public interface EaseChatFragmentHelper{
		/**
		 * set message attribute
		 */
		void onSetMessageAttributes(EMMessage message);

		/**
		 * enter to chat detail
		 */
		void onEnterToChatDetails();

		/**
		 * on avatar clicked
		 * @param username
		 */
		void onAvatarClick(String username);

		/**
		 * on avatar long pressed
		 * @param username
		 */
		void onAvatarLongClick(String username);

		/**
		 * on message bubble clicked
		 */
		boolean onMessageBubbleClick(EMMessage message);

		/**
		 * on message bubble long pressed
		 */
		void onMessageBubbleLongClick(EMMessage message);

		/**
		 * on extend menu item clicked, return true if you want to override
		 * @param view
		 * @param itemId
		 * @return
		 */
		boolean onExtendMenuItemClick(int itemId, View view);

		/**
		 * on set custom chat row provider
		 * @return
		 */
		EaseCustomChatRowProvider onSetCustomChatRowProvider();
	}

}
